package com.aspose.cells;

class zanb {
   static Object[][] a(double[] var0, double[][] var1) {
      Object[][] var2 = new Object[5][];
      int var3 = var0.length;
      int var4 = var1[0].length;
      double var5 = 0.0D;
      double var7 = 0.0D;
      double var9 = 0.0D;

      for(int var11 = 0; var11 < 5; ++var11) {
         var2[var11] = new Object[var4 + 1];
      }

      double[] var34 = new double[var4];

      int var12;
      int var15;
      for(var12 = 0; var12 < var4; ++var12) {
         double var13 = 0.0D;

         for(var15 = 0; var15 < var3; ++var15) {
            var13 += var1[var15][var12];
         }

         var34[var12] = var13 / (double)var3;
      }

      for(var12 = 0; var12 < var3; ++var12) {
         var9 += var0[var12];
      }

      var9 /= (double)var3;
      double[][] var35 = new double[var4][];

      int var14;
      int var17;
      for(int var36 = 0; var36 < var4; ++var36) {
         var35[var36] = new double[var4];

         for(var14 = 0; var14 < var4; ++var14) {
            double var39 = 0.0D;

            for(var17 = 0; var17 < var3; ++var17) {
               var39 += (var1[var17][var36] - var34[var36]) * (var1[var17][var14] - var34[var14]);
            }

            var35[var36][var14] = var39;
         }
      }

      double[] var37 = new double[var4];

      for(var14 = 0; var14 < var4; ++var14) {
         var37[var14] = 0.0D;

         for(var15 = 0; var15 < var3; ++var15) {
            var37[var14] += (var1[var15][var14] - var34[var14]) * (var0[var15] - var9);
         }
      }

      double[][] var38 = new double[var4][];

      int var16;
      for(var15 = 0; var15 < var4; ++var15) {
         var38[var15] = new double[var4 + 1];

         for(var16 = 0; var16 < var4; ++var16) {
            var38[var15][var16] = var35[var15][var16];
         }

         var38[var15][var4] = var37[var15];
      }

      double[] var40 = c(var38);
      var16 = 0;

      for(var17 = var40.length - 1; var17 >= 0 && var40[var17] == 0.0D; --var17) {
         ++var16;
      }

      double var41 = var9;

      int var19;
      for(var19 = 0; var19 < var34.length; ++var19) {
         var41 -= var40[var19] * var34[var19];
      }

      for(var19 = 0; var19 < var4; ++var19) {
         var2[0][var19] = var40[var4 - var19 - 1];
      }

      var2[0][var4] = var41;
      if (var16 == var40.length) {
         for(var19 = 0; var19 < var4; ++var19) {
            var2[1][var19] = 0.0D;
         }

         var2[2][0] = 1.0D;
         var2[2][1] = 0.0D;
         var2[3][0] = 5;
         var2[3][1] = (double)(var3 - var4);
         var2[4][0] = 0.0D;
         var2[4][1] = 0.0D;
         return var2;
      } else {
         double[] var42 = new double[var3];

         int var20;
         double var22;
         for(var20 = 0; var20 < var3; ++var20) {
            var42[var20] = 0.0D;

            for(int var21 = 0; var21 < var4; ++var21) {
               var22 = (Double)var2[0][var4 - var21 - 1];
               var42[var20] += var22 * var1[var20][var21];
            }

            var42[var20] += (Double)var2[0][var4];
         }

         for(var20 = 0; var20 < var3; ++var20) {
            var5 += (var0[var20] - var42[var20]) * (var0[var20] - var42[var20]);
            var7 += (var9 - var42[var20]) * (var9 - var42[var20]);
         }

         double var43 = (double)(var3 - var4 - 1 + var16);
         var22 = var5 / var43;
         double var24 = Math.sqrt(var22);
         var2[2][1] = var24;
         double[][] var26 = new double[var1.length][];

         for(int var27 = 0; var27 < var1.length; ++var27) {
            var26[var27] = new double[var1[var27].length + 1];

            for(int var28 = 0; var28 < var1[var27].length + 1; ++var28) {
               if (var28 == 0) {
                  var26[var27][var28] = 1.0D;
               } else {
                  var26[var27][var28] = var1[var27][var28 - 1];
               }
            }
         }

         double[][] var44 = b(var26);
         double[][] var45 = a(var44, var26);
         double[][] var29 = a(var45);

         double var32;
         for(int var30 = 0; var30 < var29.length; ++var30) {
            for(int var31 = 0; var31 < var29[var30].length; ++var31) {
               if (var30 == var31) {
                  var32 = var29[var30][var31] * var22;
                  var32 = Math.sqrt(var32);
                  var2[1][var29.length - var30 - 1] = var32;
               }
            }
         }

         double var46 = var7 / (double)(var4 - var16) / var22;
         var2[3][0] = var46;
         var2[3][1] = var43;
         var2[4][0] = var7;
         var2[4][1] = var5;
         var32 = var7 / (var7 + var5);
         var2[2][0] = var32;
         return var2;
      }
   }

   static Object[][] b(double[] var0, double[][] var1) {
      Object[][] var2 = new Object[5][];
      int var3 = var0.length;
      int var4 = var1[0].length;
      double var5 = 0.0D;
      double var7 = 0.0D;
      double var9 = 0.0D;

      for(int var11 = 0; var11 < 5; ++var11) {
         var2[var11] = new Object[var4 + 1];
      }

      double[] var33 = new double[var4];

      int var12;
      int var15;
      for(var12 = 0; var12 < var4; ++var12) {
         double var13 = 0.0D;

         for(var15 = 0; var15 < var3; ++var15) {
            var13 += var1[var15][var12];
         }

         var33[var12] = var13 / (double)var3;
      }

      for(var12 = 0; var12 < var3; ++var12) {
         var9 += var0[var12];
      }

      var9 /= (double)var3;
      double[][] var34 = new double[var4][];

      int var14;
      for(int var35 = 0; var35 < var4; ++var35) {
         var34[var35] = new double[var4];

         for(var14 = 0; var14 < var4; ++var14) {
            double var38 = 0.0D;

            for(int var17 = 0; var17 < var3; ++var17) {
               var38 += var1[var17][var14] * var1[var17][var35];
            }

            var34[var35][var14] = var38;
         }
      }

      double[] var36 = new double[var4];

      for(var14 = 0; var14 < var4; ++var14) {
         var36[var14] = 0.0D;

         for(var15 = 0; var15 < var3; ++var15) {
            var36[var14] += var0[var15] * var1[var15][var14];
         }
      }

      double[][] var37 = new double[var4][];

      for(var15 = 0; var15 < var4; ++var15) {
         var37[var15] = new double[var4 + 1];

         for(int var16 = 0; var16 < var4; ++var16) {
            var37[var15][var16] = var34[var15][var16];
         }

         var37[var15][var4] = var36[var15];
      }

      double[] var40 = c(var37);
      double var39 = 0.0D;

      for(int var18 = 0; var18 < var4; ++var18) {
         var2[0][var18] = var40[var4 - var18 - 1];
      }

      var2[0][var4] = var39;
      double[] var41 = new double[var3];

      int var19;
      double var21;
      for(var19 = 0; var19 < var3; ++var19) {
         var41[var19] = 0.0D;

         for(int var20 = 0; var20 < var4; ++var20) {
            var21 = (Double)var2[0][var4 - var20 - 1];
            var41[var19] += var21 * var1[var19][var20];
         }

         var41[var19] += (Double)var2[0][var4];
      }

      for(var19 = 0; var19 < var3; ++var19) {
         var5 += (var0[var19] - var41[var19]) * (var0[var19] - var41[var19]);
         var7 += (var9 - var41[var19]) * (var9 - var41[var19]);
      }

      double var42 = (double)(var3 - var4 - 1);
      var21 = var5 / var42;
      double var23 = Math.sqrt(var21);
      var2[2][1] = var23;
      double[][] var25 = new double[var1.length][];

      for(int var26 = 0; var26 < var1.length; ++var26) {
         var25[var26] = new double[var1[var26].length + 1];

         for(int var27 = 0; var27 < var1[var26].length + 1; ++var27) {
            if (var27 == 0) {
               var25[var26][var27] = 1.0D;
            } else {
               var25[var26][var27] = var1[var26][var27 - 1];
            }
         }
      }

      double[][] var43 = b(var25);
      double[][] var44 = a(var43, var25);
      double[][] var28 = a(var44);

      double var31;
      for(int var29 = 0; var29 < var28.length; ++var29) {
         for(int var30 = 0; var30 < var28[var29].length; ++var30) {
            if (var29 == var30) {
               var31 = var28[var29][var30] * var21;
               var31 = Math.sqrt(var31);
               var2[1][var28.length - var29 - 1] = var31;
            }
         }
      }

      double var45 = var7 / (double)var4 / var21;
      var2[3][0] = var45;
      var2[3][1] = var42;
      var2[4][0] = var7;
      var2[4][1] = var5;
      var31 = var7 / (var7 + var5);
      var2[2][0] = var31;
      return var2;
   }

   private static double[] c(double[][] var0) {
      if (var0 == null) {
         return null;
      } else {
         int var1 = var0.length;
         int var2 = var0[0].length;
         double[] var3 = new double[var1];
         boolean var4 = false;

         int var12;
         for(var12 = 0; var12 < var1; ++var12) {
            int var5 = var12;
            double var6 = var0[var12][var12];

            int var8;
            for(var8 = var12 + 1; var8 < var1; ++var8) {
               if (Math.abs(var6) < Math.abs(var0[var8][var12])) {
                  var6 = var0[var8][var12];
                  var5 = var8;
               }
            }

            double var9;
            if (var12 != var5) {
               for(var8 = 0; var8 < var2; ++var8) {
                  var9 = var0[var12][var8];
                  var0[var12][var8] = var0[var5][var8];
                  var0[var5][var8] = var9;
               }
            }

            for(var8 = var12 + 1; var8 < var1; ++var8) {
               if (var0[var8][var12] != 0.0D) {
                  var9 = -(var0[var8][var12] / var6);

                  for(int var11 = var12; var11 < var2; ++var11) {
                     var0[var8][var11] += var0[var12][var11] * var9;
                     if (Math.abs(var0[var8][var11]) < 5.0E-14D) {
                        var0[var8][var11] = 0.0D;
                     }
                  }
               }
            }
         }

         for(var12 = var1 - 1; var12 >= 0; --var12) {
            if (var12 == var1 - 1) {
               if (Math.abs(var0[var12][var12]) < 5.0E-14D) {
                  var3[var12] = 0.0D;
               } else {
                  var3[var12] = var0[var12][var2 - 1] / var0[var12][var12];
               }
            } else if (Math.abs(var0[var12][var12]) < 5.0E-14D) {
               var3[var12] = 0.0D;
            } else {
               double var13 = 0.0D;

               for(int var7 = var12 + 1; var7 < var2 - 1; ++var7) {
                  var13 += var0[var12][var7] * var3[var7];
               }

               var3[var12] = (var0[var12][var2 - 1] - var13) / var0[var12][var12];
            }
         }

         return var3;
      }
   }

   static double[][] a(double[][] var0) {
      double[][] var1 = new double[var0.length][];

      int var2;
      int var3;
      for(var2 = 0; var2 < var1.length; ++var2) {
         var1[var2] = new double[var0[0].length + var0[0].length];

         for(var3 = 0; var3 < var1[var2].length; ++var3) {
            if (var3 < var0[0].length) {
               var1[var2][var3] = var0[var2][var3];
            } else if (var3 == var2 + var0[0].length) {
               var1[var2][var3] = 1.0D;
            }
         }
      }

      var2 = var1.length;
      var3 = var1[0].length;
      int var4 = 1;

      int var7;
      int var8;
      do {
         double var5 = Math.abs(var1[var4 - 1][var4 - 1]);
         var7 = var4 - 1;

         for(var8 = var4 - 1; var8 < var2; ++var8) {
            if (Math.abs(var1[var8][var4 - 1]) > var5) {
               var5 = Math.abs(var1[var8][var4 - 1]);
               var7 = var8;
            }
         }

         double var9;
         if (var7 != var4 - 1) {
            for(var8 = 0; var8 < var3; ++var8) {
               var9 = var1[var4 - 1][var8];
               var1[var4 - 1][var8] = var1[var7][var8];
               var1[var7][var8] = var9;
            }
         }

         for(var8 = var4; var8 < var2; ++var8) {
            if (var1[var4 - 1][var4 - 1] == 0.0D) {
               return (double[][])null;
            }

            var9 = var1[var8][var4 - 1] / var1[var4 - 1][var4 - 1];

            for(int var11 = 0; var11 < var3; ++var11) {
               var1[var8][var11] -= var9 * var1[var4 - 1][var11];
            }
         }

         ++var4;
      } while(var4 <= var1.length);

      var4 = var1.length - 2;

      double var6;
      int var12;
      do {
         for(var12 = var4; var12 >= 0; --var12) {
            if (var1[var4 + 1][var4 + 1] == 0.0D) {
               return (double[][])null;
            }

            var6 = var1[var12][var4 + 1] / var1[var4 + 1][var4 + 1];
            if (Math.abs(var1[var4 + 1][var4 + 1]) < 5.0E-14D) {
               var6 = 0.0D;
            }

            for(var8 = 0; var8 < var3; ++var8) {
               var1[var12][var8] -= var6 * var1[var4 + 1][var8];
            }
         }

         --var4;
      } while(var4 >= 0);

      for(var12 = 0; var12 < var2; ++var12) {
         var6 = var1[var12][var12];
         if (Math.abs(var6) < 5.0E-14D) {
            for(var8 = 0; var8 < var3; ++var8) {
               var1[var12][var8] = 0.0D;
            }
         } else {
            for(var8 = 0; var8 < var3; ++var8) {
               var1[var12][var8] /= var6;
            }
         }
      }

      double[][] var13 = new double[var0.length][];

      for(int var14 = 0; var14 < var2; ++var14) {
         var13[var14] = new double[var2];

         for(var7 = 0; var7 < var2; ++var7) {
            var13[var14][var7] = var1[var14][var7 + var2];
         }
      }

      return var13;
   }

   static double[][] b(double[][] var0) {
      if (var0 == null) {
         return (double[][])null;
      } else {
         int var1 = var0.length;
         int var2 = var0[0].length;
         double[][] var3 = new double[var2][];

         int var4;
         for(var4 = 0; var4 < var2; ++var4) {
            var3[var4] = new double[var1];
         }

         for(var4 = 0; var4 < var2; ++var4) {
            for(int var5 = 0; var5 < var1; ++var5) {
               var3[var4][var5] = var0[var5][var4];
            }
         }

         return var3;
      }
   }

   static double[][] a(double[][] var0, double[][] var1) {
      if (var0 != null && var1 != null) {
         int var2 = var0.length;
         int var3 = var0[0].length;
         int var4 = var1[0].length;
         double[][] var5 = new double[var2][];

         int var6;
         for(var6 = 0; var6 < var2; ++var6) {
            var5[var6] = new double[var4];
         }

         for(var6 = 0; var6 < var2; ++var6) {
            for(int var7 = 0; var7 < var4; ++var7) {
               var5[var6][var7] = 0.0D;

               for(int var8 = 0; var8 < var3; ++var8) {
                  var5[var6][var7] += var0[var6][var8] * var1[var8][var7];
               }
            }
         }

         return var5;
      } else {
         return (double[][])null;
      }
   }
}
